home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the 3D Game Programming Gurus / gurus.iso / DirectX / dx9sdkcp.exe / SDK (C++) / Include / d3dx9mesh.h < prev    next >
Encoding:
C/C++ Source or Header  |  2002-12-04  |  51.8 KB  |  1,348 lines
  1. //////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  Copyright (C) Microsoft Corporation.  All Rights Reserved.
  4. //
  5. //  File:       d3dx9mesh.h
  6. //  Content:    D3DX mesh types and functions
  7. //
  8. //////////////////////////////////////////////////////////////////////////////
  9.  
  10. #include "d3dx9.h"
  11.  
  12. #ifndef __D3DX9MESH_H__
  13. #define __D3DX9MESH_H__
  14.  
  15. #include "dxfile.h"     // defines LPDIRECTXFILEDATA
  16.  
  17. // {2A835771-BF4D-43f4-8E14-82A809F17D8A}
  18. DEFINE_GUID(IID_ID3DXBaseMesh, 
  19. 0x2a835771, 0xbf4d, 0x43f4, 0x8e, 0x14, 0x82, 0xa8, 0x9, 0xf1, 0x7d, 0x8a);
  20.  
  21. // {CCAE5C3B-4DD1-4d0f-997E-4684CA64557F}
  22. DEFINE_GUID(IID_ID3DXMesh, 
  23. 0xccae5c3b, 0x4dd1, 0x4d0f, 0x99, 0x7e, 0x46, 0x84, 0xca, 0x64, 0x55, 0x7f);
  24.  
  25. // {19FBE386-C282-4659-97BD-CB869B084A6C}
  26. DEFINE_GUID(IID_ID3DXPMesh, 
  27. 0x19fbe386, 0xc282, 0x4659, 0x97, 0xbd, 0xcb, 0x86, 0x9b, 0x8, 0x4a, 0x6c);
  28.  
  29. // {4E3CA05C-D4FF-4d11-8A02-16459E08F6F4}
  30. DEFINE_GUID(IID_ID3DXSPMesh, 
  31. 0x4e3ca05c, 0xd4ff, 0x4d11, 0x8a, 0x2, 0x16, 0x45, 0x9e, 0x8, 0xf6, 0xf4);
  32.  
  33. // {0E7DBBF3-421A-4dd8-B738-A5DAC3A48767}
  34. DEFINE_GUID(IID_ID3DXSkinInfo, 
  35. 0xe7dbbf3, 0x421a, 0x4dd8, 0xb7, 0x38, 0xa5, 0xda, 0xc3, 0xa4, 0x87, 0x67);
  36.  
  37. // {0AD3E8BC-290D-4dc7-91AB-73A82755B13E}
  38. DEFINE_GUID(IID_ID3DXPatchMesh, 
  39. 0xad3e8bc, 0x290d, 0x4dc7, 0x91, 0xab, 0x73, 0xa8, 0x27, 0x55, 0xb1, 0x3e);
  40.  
  41. //patch mesh can be quads or tris
  42. typedef enum _D3DXPATCHMESHTYPE {
  43.     D3DXPATCHMESH_RECT   = 0x001,
  44.     D3DXPATCHMESH_TRI    = 0x002,
  45.     D3DXPATCHMESH_NPATCH = 0x003,
  46.  
  47.     D3DXPATCHMESH_FORCE_DWORD    = 0x7fffffff, /* force 32-bit size enum */
  48. } D3DXPATCHMESHTYPE;
  49.  
  50. // Mesh options - lower 3 bytes only, upper byte used by _D3DXMESHOPT option flags
  51. enum _D3DXMESH {
  52.     D3DXMESH_32BIT                  = 0x001, // If set, then use 32 bit indices, if not set use 16 bit indices.
  53.     D3DXMESH_DONOTCLIP              = 0x002, // Use D3DUSAGE_DONOTCLIP for VB & IB.
  54.     D3DXMESH_POINTS                 = 0x004, // Use D3DUSAGE_POINTS for VB & IB. 
  55.     D3DXMESH_RTPATCHES              = 0x008, // Use D3DUSAGE_RTPATCHES for VB & IB. 
  56.     D3DXMESH_NPATCHES               = 0x4000,// Use D3DUSAGE_NPATCHES for VB & IB. 
  57.     D3DXMESH_VB_SYSTEMMEM           = 0x010, // Use D3DPOOL_SYSTEMMEM for VB. Overrides D3DXMESH_MANAGEDVERTEXBUFFER
  58.     D3DXMESH_VB_MANAGED             = 0x020, // Use D3DPOOL_MANAGED for VB. 
  59.     D3DXMESH_VB_WRITEONLY           = 0x040, // Use D3DUSAGE_WRITEONLY for VB.
  60.     D3DXMESH_VB_DYNAMIC             = 0x080, // Use D3DUSAGE_DYNAMIC for VB.
  61.     D3DXMESH_VB_SOFTWAREPROCESSING = 0x8000, // Use D3DUSAGE_SOFTWAREPROCESSING for VB.
  62.     D3DXMESH_IB_SYSTEMMEM           = 0x100, // Use D3DPOOL_SYSTEMMEM for IB. Overrides D3DXMESH_MANAGEDINDEXBUFFER
  63.     D3DXMESH_IB_MANAGED             = 0x200, // Use D3DPOOL_MANAGED for IB.
  64.     D3DXMESH_IB_WRITEONLY           = 0x400, // Use D3DUSAGE_WRITEONLY for IB.
  65.     D3DXMESH_IB_DYNAMIC             = 0x800, // Use D3DUSAGE_DYNAMIC for IB.
  66.     D3DXMESH_IB_SOFTWAREPROCESSING= 0x10000, // Use D3DUSAGE_SOFTWAREPROCESSING for IB.
  67.  
  68.     D3DXMESH_VB_SHARE               = 0x1000, // Valid for Clone* calls only, forces cloned mesh/pmesh to share vertex buffer
  69.  
  70.     D3DXMESH_USEHWONLY              = 0x2000, // Valid for ID3DXSkinMesh::ConvertToBlendedMesh
  71.  
  72.     // Helper options
  73.     D3DXMESH_SYSTEMMEM              = 0x110, // D3DXMESH_VB_SYSTEMMEM | D3DXMESH_IB_SYSTEMMEM
  74.     D3DXMESH_MANAGED                = 0x220, // D3DXMESH_VB_MANAGED | D3DXMESH_IB_MANAGED
  75.     D3DXMESH_WRITEONLY              = 0x440, // D3DXMESH_VB_WRITEONLY | D3DXMESH_IB_WRITEONLY
  76.     D3DXMESH_DYNAMIC                = 0x880, // D3DXMESH_VB_DYNAMIC | D3DXMESH_IB_DYNAMIC
  77.     D3DXMESH_SOFTWAREPROCESSING   = 0x18000, // D3DXMESH_VB_SOFTWAREPROCESSING | D3DXMESH_IB_SOFTWAREPROCESSING
  78.  
  79. };
  80.  
  81. //patch mesh options
  82. enum _D3DXPATCHMESH {
  83.     D3DXPATCHMESH_DEFAULT = 000,
  84. };
  85. // option field values for specifying min value in D3DXGeneratePMesh and D3DXSimplifyMesh
  86. enum _D3DXMESHSIMP
  87. {
  88.     D3DXMESHSIMP_VERTEX   = 0x1,
  89.     D3DXMESHSIMP_FACE     = 0x2,
  90.  
  91. };
  92.  
  93. enum _MAX_FVF_DECL_SIZE
  94. {
  95.     MAX_FVF_DECL_SIZE = MAXD3DDECLLENGTH + 1 // +1 for END
  96. };
  97.  
  98. typedef struct ID3DXBaseMesh *LPD3DXBASEMESH;
  99. typedef struct ID3DXMesh *LPD3DXMESH;
  100. typedef struct ID3DXPMesh *LPD3DXPMESH;
  101. typedef struct ID3DXSPMesh *LPD3DXSPMESH;
  102. typedef struct ID3DXSkinInfo *LPD3DXSKININFO;
  103. typedef struct ID3DXPatchMesh *LPD3DXPATCHMESH;
  104.  
  105. typedef struct _D3DXATTRIBUTERANGE
  106. {
  107.     DWORD AttribId;
  108.     DWORD FaceStart;
  109.     DWORD FaceCount;
  110.     DWORD VertexStart;
  111.     DWORD VertexCount;
  112. } D3DXATTRIBUTERANGE;
  113.  
  114. typedef D3DXATTRIBUTERANGE* LPD3DXATTRIBUTERANGE;
  115.  
  116. typedef struct _D3DXMATERIAL
  117. {
  118.     D3DMATERIAL9  MatD3D;
  119.     LPSTR         pTextureFilename;
  120. } D3DXMATERIAL;
  121. typedef D3DXMATERIAL *LPD3DXMATERIAL;
  122.  
  123. typedef enum _D3DXEFFECTDEFAULTTYPE
  124. {
  125.     D3DXEDT_STRING = 0x1,       // pValue points to a null terminated ASCII string 
  126.     D3DXEDT_FLOATS = 0x2,       // pValue points to an array of floats - number of floats is NumBytes / sizeof(float)
  127.     D3DXEDT_DWORD  = 0x3,       // pValue points to a DWORD
  128.  
  129.     D3DXEDT_FORCEDWORD = 0x7fffffff
  130. } D3DXEFFECTDEFAULTTYPE;
  131.  
  132. typedef struct _D3DXEFFECTDEFAULT
  133. {
  134.     LPSTR                 pParamName;
  135.     D3DXEFFECTDEFAULTTYPE Type;           // type of the data pointed to by pValue
  136.     DWORD                 NumBytes;       // size in bytes of the data pointed to by pValue
  137.     LPVOID                pValue;         // data for the default of the effect
  138. } D3DXEFFECTDEFAULT, *LPD3DXEFFECTDEFAULT;
  139.  
  140. typedef struct _D3DXEFFECTINSTANCE
  141. {
  142.     LPSTR               pEffectFilename;
  143.     DWORD               NumDefaults;
  144.     LPD3DXEFFECTDEFAULT pDefaults;
  145. } D3DXEFFECTINSTANCE, *LPD3DXEFFECTINSTANCE;
  146.  
  147. typedef struct _D3DXATTRIBUTEWEIGHTS
  148. {
  149.     FLOAT Position;
  150.     FLOAT Boundary;
  151.     FLOAT Normal;
  152.     FLOAT Diffuse;
  153.     FLOAT Specular;
  154.     FLOAT Texcoord[8];
  155.     FLOAT Tangent;
  156.     FLOAT Binormal;
  157. } D3DXATTRIBUTEWEIGHTS, *LPD3DXATTRIBUTEWEIGHTS;
  158.  
  159. enum _D3DXWELDEPSILONSFLAGS
  160. {
  161.     D3DXWELDEPSILONS_WELDALL             = 0x1,  // weld all vertices marked by adjacency as being overlapping
  162.  
  163.     D3DXWELDEPSILONS_WELDPARTIALMATCHES  = 0x2,  // if a given vertex component is within epsilon, modify partial matched 
  164.                                                     // vertices so that both components identical AND if all components "equal"
  165.                                                     // remove one of the vertices
  166.     D3DXWELDEPSILONS_DONOTREMOVEVERTICES = 0x4,  // instructs weld to only allow modifications to vertices and not removal
  167.                                                     // ONLY valid if D3DXWELDEPSILONS_WELDPARTIALMATCHES is set
  168.                                                     // useful to modify vertices to be equal, but not allow vertices to be removed
  169.  
  170.     D3DXWELDEPSILONS_DONOTSPLIT          = 0x8,  // instructs weld to specify the D3DXMESHOPT_DONOTSPLIT flag when doing an Optimize(ATTR_SORT)
  171.                                                     // if this flag is not set, all vertices that are in separate attribute groups
  172.                                                     // will remain split and not welded.  Setting this flag can slow down software vertex processing
  173.  
  174. };
  175.  
  176. typedef struct _D3DXWELDEPSILONS
  177. {
  178.     FLOAT Position;                 // NOTE: This does NOT replace the epsilon in GenerateAdjacency
  179.                                             // in general, it should be the same value or greater than the one passed to GeneratedAdjacency
  180.     FLOAT BlendWeights;
  181.     FLOAT Normal;
  182.     FLOAT PSize;
  183.     FLOAT Specular;
  184.     FLOAT Diffuse;
  185.     FLOAT Texcoord[8];
  186.     FLOAT Tangent;
  187.     FLOAT Binormal;
  188.     FLOAT TessFactor;
  189. } D3DXWELDEPSILONS;
  190.  
  191. typedef D3DXWELDEPSILONS* LPD3DXWELDEPSILONS;
  192.  
  193.  
  194. #undef INTERFACE
  195. #define INTERFACE ID3DXBaseMesh
  196.  
  197. DECLARE_INTERFACE_(ID3DXBaseMesh, IUnknown)
  198. {
  199.     // IUnknown
  200.     STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
  201.     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
  202.     STDMETHOD_(ULONG, Release)(THIS) PURE;
  203.  
  204.     // ID3DXBaseMesh
  205.     STDMETHOD(DrawSubset)(THIS_ DWORD AttribId) PURE;
  206.     STDMETHOD_(DWORD, GetNumFaces)(THIS) PURE;
  207.     STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE;
  208.     STDMETHOD_(DWORD, GetFVF)(THIS) PURE;
  209.     STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) PURE;
  210.     STDMETHOD_(DWORD, GetNumBytesPerVertex)(THIS) PURE;
  211.     STDMETHOD_(DWORD, GetOptions)(THIS) PURE;
  212.     STDMETHOD(GetDevice)(THIS_ LPDIRECT3DDEVICE9* ppDevice) PURE;
  213.     STDMETHOD(CloneMeshFVF)(THIS_ DWORD Options, 
  214.                 DWORD FVF, LPDIRECT3DDEVICE9 pD3DDevice, LPD3DXMESH* ppCloneMesh) PURE;
  215.     STDMETHOD(CloneMesh)(THIS_ DWORD Options, 
  216.                 CONST D3DVERTEXELEMENT9 *pDeclaration, LPDIRECT3DDEVICE9 pD3DDevice, LPD3DXMESH* ppCloneMesh) PURE;
  217.     STDMETHOD(GetVertexBuffer)(THIS_ LPDIRECT3DVERTEXBUFFER9* ppVB) PURE;
  218.     STDMETHOD(GetIndexBuffer)(THIS_ LPDIRECT3DINDEXBUFFER9* ppIB) PURE;
  219.     STDMETHOD(LockVertexBuffer)(THIS_ DWORD Flags, void** ppData) PURE;
  220.     STDMETHOD(UnlockVertexBuffer)(THIS) PURE;
  221.     STDMETHOD(LockIndexBuffer)(THIS_ DWORD Flags, void** ppData) PURE;
  222.     STDMETHOD(UnlockIndexBuffer)(THIS) PURE;
  223.     STDMETHOD(GetAttributeTable)(
  224.                 THIS_ D3DXATTRIBUTERANGE *pAttribTable, DWORD* pAttribTableSize) PURE;
  225.  
  226.     STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ CONST DWORD* pPRep, DWORD* pAdjacency) PURE;
  227.     STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ CONST DWORD* pAdjacency, DWORD* pPRep) PURE;
  228.     STDMETHOD(GenerateAdjacency)(THIS_ FLOAT Epsilon, DWORD* pAdjacency) PURE;
  229.  
  230.     STDMETHOD(UpdateSemantics)(THIS_ D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) PURE;
  231. };
  232.  
  233.  
  234. #undef INTERFACE
  235. #define INTERFACE ID3DXMesh
  236.  
  237. DECLARE_INTERFACE_(ID3DXMesh, ID3DXBaseMesh)
  238. {
  239.     // IUnknown
  240.     STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
  241.     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
  242.     STDMETHOD_(ULONG, Release)(THIS) PURE;
  243.  
  244.     // ID3DXBaseMesh
  245.     STDMETHOD(DrawSubset)(THIS_ DWORD AttribId) PURE;
  246.     STDMETHOD_(DWORD, GetNumFaces)(THIS) PURE;
  247.     STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE;
  248.     STDMETHOD_(DWORD, GetFVF)(THIS) PURE;
  249.     STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) PURE;
  250.     STDMETHOD_(DWORD, GetNumBytesPerVertex)(THIS) PURE;
  251.     STDMETHOD_(DWORD, GetOptions)(THIS) PURE;
  252.     STDMETHOD(GetDevice)(THIS_ LPDIRECT3DDEVICE9* ppDevice) PURE;
  253.     STDMETHOD(CloneMeshFVF)(THIS_ DWORD Options, 
  254.                 DWORD FVF, LPDIRECT3DDEVICE9 pD3DDevice, LPD3DXMESH* ppCloneMesh) PURE;
  255.     STDMETHOD(CloneMesh)(THIS_ DWORD Options, 
  256.                 CONST D3DVERTEXELEMENT9 *pDeclaration, LPDIRECT3DDEVICE9 pD3DDevice, LPD3DXMESH* ppCloneMesh) PURE;
  257.     STDMETHOD(GetVertexBuffer)(THIS_ LPDIRECT3DVERTEXBUFFER9* ppVB) PURE;
  258.     STDMETHOD(GetIndexBuffer)(THIS_ LPDIRECT3DINDEXBUFFER9* ppIB) PURE;
  259.     STDMETHOD(LockVertexBuffer)(THIS_ DWORD Flags, void** ppData) PURE;
  260.     STDMETHOD(UnlockVertexBuffer)(THIS) PURE;
  261.     STDMETHOD(LockIndexBuffer)(THIS_ DWORD Flags, void** ppData) PURE;
  262.     STDMETHOD(UnlockIndexBuffer)(THIS) PURE;
  263.     STDMETHOD(GetAttributeTable)(
  264.                 THIS_ D3DXATTRIBUTERANGE *pAttribTable, DWORD* pAttribTableSize) PURE;
  265.  
  266.     STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ CONST DWORD* pPRep, DWORD* pAdjacency) PURE;
  267.     STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ CONST DWORD* pAdjacency, DWORD* pPRep) PURE;
  268.     STDMETHOD(GenerateAdjacency)(THIS_ FLOAT Epsilon, DWORD* pAdjacency) PURE;
  269.  
  270.     STDMETHOD(UpdateSemantics)(THIS_ D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) PURE;
  271.  
  272.     // ID3DXMesh
  273.     STDMETHOD(LockAttributeBuffer)(THIS_ DWORD Flags, DWORD** ppData) PURE;
  274.     STDMETHOD(UnlockAttributeBuffer)(THIS) PURE;
  275.     STDMETHOD(Optimize)(THIS_ DWORD Flags, CONST DWORD* pAdjacencyIn, DWORD* pAdjacencyOut, 
  276.                      DWORD* pFaceRemap, LPD3DXBUFFER *ppVertexRemap,  
  277.                      LPD3DXMESH* ppOptMesh) PURE;
  278.     STDMETHOD(OptimizeInplace)(THIS_ DWORD Flags, CONST DWORD* pAdjacencyIn, DWORD* pAdjacencyOut, 
  279.                      DWORD* pFaceRemap, LPD3DXBUFFER *ppVertexRemap) PURE;
  280.     STDMETHOD(SetAttributeTable)(THIS_ CONST D3DXATTRIBUTERANGE *pAttribTable, DWORD cAttribTableSize) PURE;
  281. };
  282.  
  283.  
  284. #undef INTERFACE
  285. #define INTERFACE ID3DXPMesh
  286.  
  287. DECLARE_INTERFACE_(ID3DXPMesh, ID3DXBaseMesh)
  288. {
  289.     // IUnknown
  290.     STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
  291.     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
  292.     STDMETHOD_(ULONG, Release)(THIS) PURE;
  293.  
  294.     // ID3DXBaseMesh
  295.     STDMETHOD(DrawSubset)(THIS_ DWORD AttribId) PURE;
  296.     STDMETHOD_(DWORD, GetNumFaces)(THIS) PURE;
  297.     STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE;
  298.     STDMETHOD_(DWORD, GetFVF)(THIS) PURE;
  299.     STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) PURE;
  300.     STDMETHOD_(DWORD, GetNumBytesPerVertex)(THIS) PURE;
  301.     STDMETHOD_(DWORD, GetOptions)(THIS) PURE;
  302.     STDMETHOD(GetDevice)(THIS_ LPDIRECT3DDEVICE9* ppDevice) PURE;
  303.     STDMETHOD(CloneMeshFVF)(THIS_ DWORD Options, 
  304.                 DWORD FVF, LPDIRECT3DDEVICE9 pD3DDevice, LPD3DXMESH* ppCloneMesh) PURE;
  305.     STDMETHOD(CloneMesh)(THIS_ DWORD Options, 
  306.                 CONST D3DVERTEXELEMENT9 *pDeclaration, LPDIRECT3DDEVICE9 pD3DDevice, LPD3DXMESH* ppCloneMesh) PURE;
  307.     STDMETHOD(GetVertexBuffer)(THIS_ LPDIRECT3DVERTEXBUFFER9* ppVB) PURE;
  308.     STDMETHOD(GetIndexBuffer)(THIS_ LPDIRECT3DINDEXBUFFER9* ppIB) PURE;
  309.     STDMETHOD(LockVertexBuffer)(THIS_ DWORD Flags, void** ppData) PURE;
  310.     STDMETHOD(UnlockVertexBuffer)(THIS) PURE;
  311.     STDMETHOD(LockIndexBuffer)(THIS_ DWORD Flags, void** ppData) PURE;
  312.     STDMETHOD(UnlockIndexBuffer)(THIS) PURE;
  313.     STDMETHOD(GetAttributeTable)(
  314.                 THIS_ D3DXATTRIBUTERANGE *pAttribTable, DWORD* pAttribTableSize) PURE;
  315.  
  316.     STDMETHOD(ConvertPointRepsToAdjacency)(THIS_ CONST DWORD* pPRep, DWORD* pAdjacency) PURE;
  317.     STDMETHOD(ConvertAdjacencyToPointReps)(THIS_ CONST DWORD* pAdjacency, DWORD* pPRep) PURE;
  318.     STDMETHOD(GenerateAdjacency)(THIS_ FLOAT Epsilon, DWORD* pAdjacency) PURE;
  319.  
  320.     STDMETHOD(UpdateSemantics)(THIS_ D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) PURE;
  321.  
  322.     // ID3DXPMesh
  323.     STDMETHOD(ClonePMeshFVF)(THIS_ DWORD Options, 
  324.                 DWORD FVF, LPDIRECT3DDEVICE9 pD3D, LPD3DXPMESH* ppCloneMesh) PURE;
  325.     STDMETHOD(ClonePMesh)(THIS_ DWORD Options, 
  326.                 CONST D3DVERTEXELEMENT9 *pDeclaration, LPDIRECT3DDEVICE9 pD3D, LPD3DXPMESH* ppCloneMesh) PURE;
  327.     STDMETHOD(SetNumFaces)(THIS_ DWORD Faces) PURE;
  328.     STDMETHOD(SetNumVertices)(THIS_ DWORD Vertices) PURE;
  329.     STDMETHOD_(DWORD, GetMaxFaces)(THIS) PURE;
  330.     STDMETHOD_(DWORD, GetMinFaces)(THIS) PURE;
  331.     STDMETHOD_(DWORD, GetMaxVertices)(THIS) PURE;
  332.     STDMETHOD_(DWORD, GetMinVertices)(THIS) PURE;
  333.     STDMETHOD(Save)(THIS_ IStream *pStream, CONST D3DXMATERIAL* pMaterials, CONST D3DXEFFECTINSTANCE* pEffectInstances, DWORD NumMaterials) PURE;
  334.  
  335.     STDMETHOD(Optimize)(THIS_ DWORD Flags, DWORD* pAdjacencyOut, 
  336.                      DWORD* pFaceRemap, LPD3DXBUFFER *ppVertexRemap,  
  337.                      LPD3DXMESH* ppOptMesh) PURE;
  338.  
  339.     STDMETHOD(OptimizeBaseLOD)(THIS_ DWORD Flags, DWORD* pFaceRemap) PURE;
  340.     STDMETHOD(TrimByFaces)(THIS_ DWORD NewFacesMin, DWORD NewFacesMax, DWORD *rgiFaceRemap, DWORD *rgiVertRemap) PURE;
  341.     STDMETHOD(TrimByVertices)(THIS_ DWORD NewVerticesMin, DWORD NewVerticesMax, DWORD *rgiFaceRemap, DWORD *rgiVertRemap) PURE;
  342.  
  343.     STDMETHOD(GetAdjacency)(THIS_ DWORD* pAdjacency) PURE;
  344.  
  345.     //  Used to generate the immediate "ancestor" for each vertex when it is removed by a vsplit.  Allows generation of geomorphs
  346.     //     Vertex buffer must be equal to or greater than the maximum number of vertices in the pmesh
  347.     STDMETHOD(GenerateVertexHistory)(THIS_ DWORD* pVertexHistory) PURE;
  348. };
  349.  
  350.  
  351. #undef INTERFACE
  352. #define INTERFACE ID3DXSPMesh
  353.  
  354. DECLARE_INTERFACE_(ID3DXSPMesh, IUnknown)
  355. {
  356.     // IUnknown
  357.     STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
  358.     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
  359.     STDMETHOD_(ULONG, Release)(THIS) PURE;
  360.  
  361.     // ID3DXSPMesh
  362.     STDMETHOD_(DWORD, GetNumFaces)(THIS) PURE;
  363.     STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE;
  364.     STDMETHOD_(DWORD, GetFVF)(THIS) PURE;
  365.     STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) PURE;
  366.     STDMETHOD_(DWORD, GetOptions)(THIS) PURE;
  367.     STDMETHOD(GetDevice)(THIS_ LPDIRECT3DDEVICE9* ppDevice) PURE;
  368.     STDMETHOD(CloneMeshFVF)(THIS_ DWORD Options, 
  369.                 DWORD FVF, LPDIRECT3DDEVICE9 pD3D, DWORD *pAdjacencyOut, DWORD *pVertexRemapOut, LPD3DXMESH* ppCloneMesh) PURE;
  370.     STDMETHOD(CloneMesh)(THIS_ DWORD Options, 
  371.                 CONST D3DVERTEXELEMENT9 *pDeclaration, LPDIRECT3DDEVICE9 pD3DDevice, DWORD *pAdjacencyOut, DWORD *pVertexRemapOut, LPD3DXMESH* ppCloneMesh) PURE;
  372.     STDMETHOD(ClonePMeshFVF)(THIS_ DWORD Options, 
  373.                 DWORD FVF, LPDIRECT3DDEVICE9 pD3D, DWORD *pVertexRemapOut, FLOAT *pErrorsByFace, LPD3DXPMESH* ppCloneMesh) PURE;
  374.     STDMETHOD(ClonePMesh)(THIS_ DWORD Options, 
  375.                 CONST D3DVERTEXELEMENT9 *pDeclaration, LPDIRECT3DDEVICE9 pD3D, DWORD *pVertexRemapOut, FLOAT *pErrorsbyFace, LPD3DXPMESH* ppCloneMesh) PURE;
  376.     STDMETHOD(ReduceFaces)(THIS_ DWORD Faces) PURE;
  377.     STDMETHOD(ReduceVertices)(THIS_ DWORD Vertices) PURE;
  378.     STDMETHOD_(DWORD, GetMaxFaces)(THIS) PURE;
  379.     STDMETHOD_(DWORD, GetMaxVertices)(THIS) PURE;
  380.     STDMETHOD(GetVertexAttributeWeights)(THIS_ LPD3DXATTRIBUTEWEIGHTS pVertexAttributeWeights) PURE;
  381.     STDMETHOD(GetVertexWeights)(THIS_ FLOAT *pVertexWeights) PURE;
  382. };
  383.  
  384. #define UNUSED16 (0xffff)
  385. #define UNUSED32 (0xffffffff)
  386.  
  387. // ID3DXMesh::Optimize options - upper byte only, lower 3 bytes used from _D3DXMESH option flags
  388. enum _D3DXMESHOPT {
  389.     D3DXMESHOPT_COMPACT       = 0x01000000,
  390.     D3DXMESHOPT_ATTRSORT      = 0x02000000,
  391.     D3DXMESHOPT_VERTEXCACHE   = 0x04000000,
  392.     D3DXMESHOPT_STRIPREORDER  = 0x08000000,
  393.     D3DXMESHOPT_IGNOREVERTS   = 0x10000000,  // optimize faces only, don't touch vertices
  394.     D3DXMESHOPT_DONOTSPLIT    = 0x20000000,  // do not split vertices shared between attribute groups when attribute sorting
  395.     D3DXMESHOPT_DEVICEINDEPENDENT = 0x00400000,  // Only affects VCache.  uses a static known good cache size for all cards
  396.                             
  397.     // D3DXMESHOPT_SHAREVB has been removed, please use D3DXMESH_VB_SHARE instead
  398.  
  399. };
  400.  
  401. // Subset of the mesh that has the same attribute and bone combination.
  402. // This subset can be rendered in a single draw call
  403. typedef struct _D3DXBONECOMBINATION
  404. {
  405.     DWORD AttribId;
  406.     DWORD FaceStart;
  407.     DWORD FaceCount;
  408.     DWORD VertexStart;
  409.     DWORD VertexCount;
  410.     DWORD* BoneId;
  411. } D3DXBONECOMBINATION, *LPD3DXBONECOMBINATION;
  412.  
  413. // The following types of patch combinations are supported:
  414. // Patch type   Basis       Degree
  415. // Rect         Bezier      2,3,5
  416. // Rect         B-Spline    2,3,5
  417. // Rect         Catmull-Rom 3
  418. // Tri          Bezier      2,3,5
  419. // N-Patch      N/A         3
  420.  
  421. typedef struct _D3DXPATCHINFO
  422. {
  423.     D3DXPATCHMESHTYPE PatchType;
  424.     D3DDEGREETYPE Degree;
  425.     D3DBASISTYPE Basis;
  426. } D3DXPATCHINFO, *LPD3DXPATCHINFO;
  427.  
  428. #undef INTERFACE
  429. #define INTERFACE ID3DXPatchMesh
  430.  
  431. DECLARE_INTERFACE_(ID3DXPatchMesh, IUnknown)
  432. {
  433.     // IUnknown
  434.     STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
  435.     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
  436.     STDMETHOD_(ULONG, Release)(THIS) PURE;
  437.  
  438.     // ID3DXPatchMesh
  439.  
  440.     // Return creation parameters
  441.     STDMETHOD_(DWORD, GetNumPatches)(THIS) PURE;
  442.     STDMETHOD_(DWORD, GetNumVertices)(THIS) PURE;
  443.     STDMETHOD(GetDeclaration)(THIS_ LPD3DVERTEXELEMENT9) PURE;
  444.     STDMETHOD_(DWORD, GetControlVerticesPerPatch)(THIS) PURE;
  445.     STDMETHOD_(DWORD, GetOptions)(THIS) PURE;
  446.     STDMETHOD(GetDevice)(THIS_ LPDIRECT3DDEVICE9 *ppDevice) PURE;
  447.     STDMETHOD(GetPatchInfo)(THIS_ LPD3DXPATCHINFO PatchInfo) PURE;
  448.  
  449.     // Control mesh access    
  450.     STDMETHOD(GetVertexBuffer)(THIS_ LPDIRECT3DVERTEXBUFFER9* ppVB) PURE;
  451.     STDMETHOD(GetIndexBuffer)(THIS_ LPDIRECT3DINDEXBUFFER9* ppIB) PURE;
  452.     STDMETHOD(LockVertexBuffer)(THIS_ DWORD flags, void** ppData) PURE;
  453.     STDMETHOD(UnlockVertexBuffer)(THIS) PURE;
  454.     STDMETHOD(LockIndexBuffer)(THIS_ DWORD flags, void** ppData) PURE;
  455.     STDMETHOD(UnlockIndexBuffer)(THIS) PURE;
  456.     STDMETHOD(LockAttributeBuffer)(THIS_ DWORD flags, DWORD** ppData) PURE;
  457.     STDMETHOD(UnlockAttributeBuffer)(THIS) PURE;
  458.  
  459.     // This function returns the size of the tessellated mesh given a tessellation level.
  460.     // This assumes uniform tessellation. For adaptive tessellation the Adaptive parameter must
  461.     // be set to TRUE and TessellationLevel should be the max tessellation.
  462.     // This will result in the max mesh size necessary for adaptive tessellation.    
  463.     STDMETHOD(GetTessSize)(THIS_ FLOAT fTessLevel,DWORD Adapative, DWORD *NumTriangles,DWORD *NumVertices) PURE;
  464.     
  465.     //GenerateAdjacency determines which patches are adjacent with provided tolerance
  466.     //this information is used internally to optimize tessellation
  467.     STDMETHOD(GenerateAdjacency)(THIS_ FLOAT Tolerance) PURE;
  468.     
  469.     //CloneMesh Creates a new patchmesh with the specified decl, and converts the vertex buffer
  470.     //to the new decl. Entries in the new decl which are new are set to 0. If the current mesh
  471.     //has adjacency, the new mesh will also have adjacency
  472.     STDMETHOD(CloneMesh)(THIS_ DWORD Options, CONST D3DVERTEXELEMENT9 *pDecl, LPD3DXPATCHMESH *pMesh) PURE;
  473.     
  474.     // Optimizes the patchmesh for efficient tessellation. This function is designed
  475.     // to perform one time optimization for patch meshes that need to be tessellated
  476.     // repeatedly by calling the Tessellate() method. The optimization performed is
  477.     // independent of the actual tessellation level used.
  478.     // Currently Flags is unused.
  479.     // If vertices are changed, Optimize must be called again
  480.     STDMETHOD(Optimize)(THIS_ DWORD flags) PURE;
  481.  
  482.     //gets and sets displacement parameters
  483.     //displacement maps can only be 2D textures MIP-MAPPING is ignored for non adapative tessellation
  484.     STDMETHOD(SetDisplaceParam)(THIS_ LPDIRECT3DBASETEXTURE9 Texture,
  485.                               D3DTEXTUREFILTERTYPE MinFilter,
  486.                               D3DTEXTUREFILTERTYPE MagFilter,
  487.                               D3DTEXTUREFILTERTYPE MipFilter,
  488.                               D3DTEXTUREADDRESS Wrap,
  489.                               DWORD dwLODBias) PURE;
  490.  
  491.     STDMETHOD(GetDisplaceParam)(THIS_ LPDIRECT3DBASETEXTURE9 *Texture,
  492.                                 D3DTEXTUREFILTERTYPE *MinFilter,
  493.                                 D3DTEXTUREFILTERTYPE *MagFilter,
  494.                                 D3DTEXTUREFILTERTYPE *MipFilter,
  495.                                 D3DTEXTUREADDRESS *Wrap,
  496.                                 DWORD *dwLODBias) PURE;
  497.         
  498.     // Performs the uniform tessellation based on the tessellation level. 
  499.     // This function will perform more efficiently if the patch mesh has been optimized using the Optimize() call.
  500.     STDMETHOD(Tessellate)(THIS_ FLOAT fTessLevel,LPD3DXMESH pMesh) PURE;
  501.  
  502.     // Performs adaptive tessellation based on the Z based adaptive tessellation criterion.
  503.     // pTrans specifies a 4D vector that is dotted with the vertices to get the per vertex
  504.     // adaptive tessellation amount. Each edge is tessellated to the average of the criterion
  505.     // at the 2 vertices it connects.
  506.     // MaxTessLevel specifies the upper limit for adaptive tesselation.
  507.     // This function will perform more efficiently if the patch mesh has been optimized using the Optimize() call.
  508.     STDMETHOD(TessellateAdaptive)(THIS_ D3DXVECTOR4 *pTrans,DWORD dwMaxTessLevel, DWORD dwMinTessLevel,LPD3DXMESH pMesh) PURE;
  509.  
  510. };
  511.  
  512. #undef INTERFACE
  513. #define INTERFACE ID3DXSkinInfo
  514.  
  515. DECLARE_INTERFACE_(ID3DXSkinInfo, IUnknown)
  516. {
  517.     // IUnknown
  518.     STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
  519.     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
  520.     STDMETHOD_(ULONG, Release)(THIS) PURE;
  521.  
  522.     // Specify the which vertices do each bones influence and by how much
  523.     STDMETHOD(SetBoneInfluence)(THIS_ DWORD bone, DWORD numInfluences, CONST DWORD* vertices, CONST FLOAT* weights) PURE;
  524.     STDMETHOD_(DWORD, GetNumBoneInfluences)(THIS_ DWORD bone) PURE;
  525.     STDMETHOD(GetBoneInfluence)(THIS_ DWORD bone, DWORD* vertices, FLOAT* weights) PURE;
  526.     STDMETHOD(GetMaxVertexInfluences)(THIS_ DWORD* maxVertexInfluences) PURE;
  527.     STDMETHOD_(DWORD, GetNumBones)(THIS) PURE;
  528.  
  529.     // This gets the max face influences based on a triangle mesh with the specified index buffer
  530.     STDMETHOD(GetMaxFaceInfluences)(THIS_ LPDIRECT3DINDEXBUFFER9 pIB, DWORD NumFaces, DWORD* maxFaceInfluences) PURE;
  531.     
  532.     // Set min bone influence. Bone influences that are smaller than this are ignored
  533.     STDMETHOD(SetMinBoneInfluence)(THIS_ FLOAT MinInfl) PURE;
  534.     // Get min bone influence. 
  535.     STDMETHOD_(FLOAT, GetMinBoneInfluence)(THIS) PURE;
  536.     
  537.     // Bone names are returned by D3DXLoadSkinMeshFromXof. They are not used by any other method of this object
  538.     STDMETHOD(SetBoneName)(THIS_ DWORD Bone, LPCSTR pName) PURE; // pName is copied to an internal string buffer
  539.     STDMETHOD_(LPCSTR, GetBoneName)(THIS_ DWORD Bone) PURE; // A pointer to an internal string buffer is returned. Do not free this.
  540.     
  541.     // Bone offset matrices are returned by D3DXLoadSkinMeshFromXof. They are not used by any other method of this object
  542.     STDMETHOD(SetBoneOffsetMatrix)(THIS_ DWORD Bone, LPD3DXMATRIX pBoneTransform) PURE; // pBoneTransform is copied to an internal buffer
  543.     STDMETHOD_(LPD3DXMATRIX, GetBoneOffsetMatrix)(THIS_ DWORD Bone) PURE; // A pointer to an internal matrix is returned. Do not free this.
  544.     
  545.     // Clone a skin info object
  546.     STDMETHOD(Clone)(THIS_ LPD3DXSKININFO* ppSkinInfo) PURE;
  547.     
  548.     // Update bone influence information to match vertices after they are reordered. This should be called 
  549.     // if the target vertex buffer has been reordered externally.
  550.     STDMETHOD(Remap)(THIS_ DWORD NumVertices, DWORD* pVertexRemap) PURE;
  551.  
  552.     // These methods enable the modification of the vertex layout of the vertices that will be skinned
  553.     STDMETHOD(SetFVF)(THIS_ DWORD FVF) PURE;
  554.     STDMETHOD(SetDeclaration)(THIS_ CONST D3DVERTEXELEMENT9 *pDeclaration) PURE;
  555.     STDMETHOD_(DWORD, GetFVF)(THIS) PURE;
  556.     STDMETHOD(GetDeclaration)(THIS_ D3DVERTEXELEMENT9 Declaration[MAX_FVF_DECL_SIZE]) PURE;
  557.  
  558.     // Apply SW skinning based on current pose matrices to the target vertices.
  559.     STDMETHOD(UpdateSkinnedMesh)(THIS_ 
  560.         CONST D3DXMATRIX* pBoneTransforms, 
  561.         CONST D3DXMATRIX* pBoneInvTransposeTransforms, 
  562.         PVOID pVerticesSrc, 
  563.         PVOID pVerticesDst) PURE;
  564.  
  565.     // Takes a mesh and returns a new mesh with per vertex blend weights and a bone combination
  566.     // table that describes which bones affect which subsets of the mesh
  567.     STDMETHOD(ConvertToBlendedMesh)(THIS_ 
  568.         LPD3DXMESH pMesh,
  569.         DWORD Options, 
  570.         CONST DWORD *pAdjacencyIn, 
  571.         LPDWORD pAdjacencyOut,
  572.         DWORD* pFaceRemap, 
  573.         LPD3DXBUFFER *ppVertexRemap, 
  574.         DWORD* pMaxFaceInfl,
  575.         DWORD* pNumBoneCombinations, 
  576.         LPD3DXBUFFER* ppBoneCombinationTable, 
  577.         LPD3DXMESH* ppMesh) PURE;
  578.  
  579.     // Takes a mesh and returns a new mesh with per vertex blend weights and indices 
  580.     // and a bone combination table that describes which bones palettes affect which subsets of the mesh
  581.     STDMETHOD(ConvertToIndexedBlendedMesh)(THIS_ 
  582.         LPD3DXMESH pMesh,
  583.         DWORD Options, 
  584.         DWORD paletteSize, 
  585.         CONST DWORD *pAdjacencyIn, 
  586.         LPDWORD pAdjacencyOut, 
  587.         DWORD* pFaceRemap, 
  588.         LPD3DXBUFFER *ppVertexRemap, 
  589.         DWORD* pMaxVertexInfl,
  590.         DWORD* pNumBoneCombinations, 
  591.         LPD3DXBUFFER* ppBoneCombinationTable, 
  592.         LPD3DXMESH* ppMesh) PURE;
  593. };
  594.  
  595. #ifdef __cplusplus
  596. extern "C" {
  597. #endif //__cplusplus
  598.  
  599.  
  600. HRESULT WINAPI 
  601.     D3DXCreateMesh(
  602.         DWORD NumFaces, 
  603.         DWORD NumVertices, 
  604.         DWORD Options, 
  605.         CONST D3DVERTEXELEMENT9 *pDeclaration, 
  606.         LPDIRECT3DDEVICE9 pD3D, 
  607.         LPD3DXMESH* ppMesh);
  608.  
  609. HRESULT WINAPI 
  610.     D3DXCreateMeshFVF(
  611.         DWORD NumFaces, 
  612.         DWORD NumVertices, 
  613.         DWORD Options, 
  614.         DWORD FVF, 
  615.         LPDIRECT3DDEVICE9 pD3D, 
  616.         LPD3DXMESH* ppMesh);
  617.  
  618. HRESULT WINAPI 
  619.     D3DXCreateSPMesh(
  620.         LPD3DXMESH pMesh, 
  621.         CONST DWORD* pAdjacency, 
  622.         CONST D3DXATTRIBUTEWEIGHTS *pVertexAttributeWeights,
  623.         CONST FLOAT *pVertexWeights,
  624.         LPD3DXSPMESH* ppSMesh);
  625.  
  626. // clean a mesh up for simplification, try to make manifold
  627. HRESULT WINAPI
  628.     D3DXCleanMesh(
  629.     LPD3DXMESH pMeshIn,
  630.     CONST DWORD* pAdjacencyIn,
  631.     LPD3DXMESH* ppMeshOut,
  632.     DWORD* pAdjacencyOut,
  633.     LPD3DXBUFFER* ppErrorsAndWarnings);
  634.  
  635. HRESULT WINAPI
  636.     D3DXValidMesh(
  637.     LPD3DXMESH pMeshIn,
  638.     CONST DWORD* pAdjacency,
  639.     LPD3DXBUFFER* ppErrorsAndWarnings);
  640.  
  641. HRESULT WINAPI 
  642.     D3DXGeneratePMesh(
  643.         LPD3DXMESH pMesh, 
  644.         CONST DWORD* pAdjacency, 
  645.         CONST D3DXATTRIBUTEWEIGHTS *pVertexAttributeWeights,
  646.         CONST FLOAT *pVertexWeights,
  647.         DWORD MinValue, 
  648.         DWORD Options, 
  649.         LPD3DXPMESH* ppPMesh);
  650.  
  651. HRESULT WINAPI 
  652.     D3DXSimplifyMesh(
  653.         LPD3DXMESH pMesh, 
  654.         CONST DWORD* pAdjacency, 
  655.         CONST D3DXATTRIBUTEWEIGHTS *pVertexAttributeWeights,
  656.         CONST FLOAT *pVertexWeights,
  657.         DWORD MinValue, 
  658.         DWORD Options, 
  659.         LPD3DXMESH* ppMesh);
  660.  
  661. HRESULT WINAPI 
  662.     D3DXComputeBoundingSphere(
  663.         LPD3DXVECTOR3 pFirstPosition,       // pointer to first position
  664.         DWORD NumVertices, 
  665.         DWORD dwStride,                     // count in bytes to subsequent position vectors
  666.         D3DXVECTOR3 *pCenter, 
  667.         FLOAT *pRadius);
  668.  
  669. HRESULT WINAPI 
  670.     D3DXComputeBoundingBox(
  671.         LPD3DXVECTOR3 pFirstPosition,       // pointer to first position
  672.         DWORD NumVertices, 
  673.         DWORD dwStride,                     // count in bytes to subsequent position vectors
  674.         D3DXVECTOR3 *pMin, 
  675.         D3DXVECTOR3 *pMax);
  676.  
  677. HRESULT WINAPI 
  678.     D3DXComputeNormals(
  679.         LPD3DXBASEMESH pMesh,
  680.         CONST DWORD *pAdjacency);
  681.  
  682. HRESULT WINAPI 
  683.     D3DXCreateBuffer(
  684.         DWORD NumBytes, 
  685.         LPD3DXBUFFER *ppBuffer);
  686.  
  687.  
  688. HRESULT WINAPI
  689.     D3DXLoadMeshFromXA(
  690.         LPCSTR pFilename, 
  691.         DWORD Options, 
  692.         LPDIRECT3DDEVICE9 pD3D, 
  693.         LPD3DXBUFFER *ppAdjacency,
  694.         LPD3DXBUFFER *ppMaterials, 
  695.         LPD3DXBUFFER *ppEffectInstances, 
  696.         DWORD *pNumMaterials,
  697.         LPD3DXMESH *ppMesh);
  698.  
  699. HRESULT WINAPI
  700.     D3DXLoadMeshFromXW(
  701.         LPCWSTR pFilename, 
  702.         DWORD Options, 
  703.         LPDIRECT3DDEVICE9 pD3D, 
  704.         LPD3DXBUFFER *ppAdjacency,
  705.         LPD3DXBUFFER *ppMaterials, 
  706.         LPD3DXBUFFER *ppEffectInstances, 
  707.         DWORD *pNumMaterials,
  708.         LPD3DXMESH *ppMesh);
  709.  
  710. #ifdef UNICODE
  711. #define D3DXLoadMeshFromX D3DXLoadMeshFromXW
  712. #else
  713. #define D3DXLoadMeshFromX D3DXLoadMeshFromXA
  714. #endif
  715.  
  716. HRESULT WINAPI 
  717.     D3DXLoadMeshFromXInMemory(
  718.         LPCVOID Memory,
  719.         DWORD SizeOfMemory,
  720.         DWORD Options, 
  721.         LPDIRECT3DDEVICE9 pD3D, 
  722.         LPD3DXBUFFER *ppAdjacency,
  723.         LPD3DXBUFFER *ppMaterials, 
  724.         LPD3DXBUFFER *ppEffectInstances, 
  725.         DWORD *pNumMaterials,
  726.         LPD3DXMESH *ppMesh);
  727.  
  728. HRESULT WINAPI 
  729.     D3DXLoadMeshFromXResource(
  730.         HMODULE Module,
  731.         LPCSTR Name,
  732.         LPCSTR Type,
  733.         DWORD Options, 
  734.         LPDIRECT3DDEVICE9 pD3D, 
  735.         LPD3DXBUFFER *ppAdjacency,
  736.         LPD3DXBUFFER *ppMaterials, 
  737.         LPD3DXBUFFER *ppEffectInstances, 
  738.         DWORD *pNumMaterials,
  739.         LPD3DXMESH *ppMesh);
  740.  
  741. HRESULT WINAPI 
  742.     D3DXSaveMeshToXA(
  743.         LPCSTR pFilename,
  744.         LPD3DXMESH pMesh,
  745.         CONST DWORD* pAdjacency,
  746.         CONST D3DXMATERIAL* pMaterials,
  747.         CONST D3DXEFFECTINSTANCE* pEffectInstances, 
  748.         DWORD NumMaterials,
  749.         DWORD Format
  750.         );
  751.  
  752. HRESULT WINAPI 
  753.     D3DXSaveMeshToXW(
  754.         LPCWSTR pFilename,
  755.         LPD3DXMESH pMesh,
  756.         CONST DWORD* pAdjacency,
  757.         CONST D3DXMATERIAL* pMaterials,
  758.         CONST D3DXEFFECTINSTANCE* pEffectInstances, 
  759.         DWORD NumMaterials,
  760.         DWORD Format
  761.         );
  762.         
  763. #ifdef UNICODE
  764. #define D3DXSaveMeshToX D3DXSaveMeshToXW
  765. #else
  766. #define D3DXSaveMeshToX D3DXSaveMeshToXA
  767. #endif
  768.         
  769.  
  770. HRESULT WINAPI 
  771.     D3DXCreatePMeshFromStream(
  772.         IStream *pStream, 
  773.         DWORD Options,
  774.         LPDIRECT3DDEVICE9 pD3DDevice, 
  775.         LPD3DXBUFFER *ppMaterials,
  776.         LPD3DXBUFFER *ppEffectInstances, 
  777.         DWORD* pNumMaterials,
  778.         LPD3DXPMESH *ppPMesh);
  779.  
  780. // Creates a skin info object based on the number of vertices, number of bones, and a declaration describing the vertex layout of the target vertices
  781. // The bone names and initial bone transforms are not filled in the skin info object by this method.
  782. HRESULT WINAPI
  783.     D3DXCreateSkinInfo(
  784.         DWORD NumVertices,
  785.         CONST D3DVERTEXELEMENT9 *pDeclaration, 
  786.         DWORD NumBones,
  787.         LPD3DXSKININFO* ppSkinInfo);
  788.         
  789. // Creates a skin info object based on the number of vertices, number of bones, and a FVF describing the vertex layout of the target vertices
  790. // The bone names and initial bone transforms are not filled in the skin info object by this method.
  791. HRESULT WINAPI
  792.     D3DXCreateSkinInfoFVF(
  793.         DWORD NumVertices,
  794.         DWORD FVF,
  795.         DWORD NumBones,
  796.         LPD3DXSKININFO* ppSkinInfo);
  797.         
  798. #ifdef __cplusplus
  799. }
  800.  
  801. extern "C" {
  802. #endif //__cplusplus
  803.  
  804. HRESULT WINAPI 
  805.     D3DXLoadMeshFromXof(
  806.         LPDIRECTXFILEDATA pXofObjMesh, 
  807.         DWORD Options, 
  808.         LPDIRECT3DDEVICE9 pD3DDevice, 
  809.         LPD3DXBUFFER *ppAdjacency,
  810.         LPD3DXBUFFER *ppMaterials, 
  811.         LPD3DXBUFFER *ppEffectInstances, 
  812.         DWORD *pNumMaterials,
  813.         LPD3DXMESH *ppMesh);
  814.  
  815. // This similar to D3DXLoadMeshFromXof, except also returns skinning info if present in the file
  816. // If skinning info is not present, ppSkinInfo will be NULL     
  817. HRESULT WINAPI
  818.     D3DXLoadSkinMeshFromXof(
  819.         LPDIRECTXFILEDATA pxofobjMesh, 
  820.         DWORD Options,
  821.         LPDIRECT3DDEVICE9 pD3D,
  822.         LPD3DXBUFFER* ppAdjacency,
  823.         LPD3DXBUFFER* ppMaterials,
  824.         LPD3DXBUFFER *ppEffectInstances, 
  825.         DWORD *pMatOut,
  826.         LPD3DXSKININFO* ppSkinInfo,
  827.         LPD3DXMESH* ppMesh);
  828.  
  829. // The inverse of D3DXConvertTo{Indexed}BlendedMesh() functions. It figures out the skinning info from
  830. // the mesh and the bone combination table and populates a skin info object with that data. The bone
  831. // names and initial bone transforms are not filled in the skin info object by this method. This works
  832. // with either a non-indexed or indexed blended mesh. It examines the FVF or declarator of the mesh to
  833. // determine what type it is.
  834. HRESULT WINAPI
  835.     D3DXCreateSkinInfoFromBlendedMesh(
  836.         LPD3DXBASEMESH pMesh,
  837.         DWORD NumBoneCombinations,
  838.         LPD3DXBONECOMBINATION pBoneCombinationTable,
  839.         LPD3DXSKININFO* ppSkinInfo);
  840.         
  841. HRESULT WINAPI
  842.     D3DXTessellateNPatches(
  843.         LPD3DXMESH pMeshIn,             
  844.         CONST DWORD* pAdjacencyIn,             
  845.         FLOAT NumSegs,                    
  846.         BOOL  QuadraticInterpNormals,     // if false use linear intrep for normals, if true use quadratic
  847.         LPD3DXMESH *ppMeshOut,
  848.         LPD3DXBUFFER *ppAdjacencyOut);
  849.  
  850.  
  851. //generates implied outputdecl from input decl
  852. //the decl generated from this should be used to generate the output decl for
  853. //the tessellator subroutines. 
  854.  
  855. HRESULT WINAPI
  856.     D3DXGenerateOutputDecl(
  857.         D3DVERTEXELEMENT9 *pOutput,
  858.         D3DVERTEXELEMENT9 *pInput);
  859.  
  860. //loads patches from an XFileData
  861. //since an X file can have up to 6 different patch meshes in it,
  862. //returns them in an array - pNumPatches will contain the number of
  863. //meshes in the actual file. 
  864. HRESULT WINAPI
  865.     D3DXLoadPatchMeshFromXof(
  866.         LPDIRECTXFILEDATA pXofObjMesh,
  867.         DWORD Options,
  868.         LPDIRECT3DDEVICE9 pDevice,
  869.         LPD3DXBUFFER *ppMaterials,
  870.         LPD3DXBUFFER *ppEffectInstances, 
  871.         PDWORD pNumMaterials,
  872.         LPD3DXPATCHMESH *ppMesh);
  873.  
  874. //computes the size a single rect patch.
  875. HRESULT WINAPI
  876.     D3DXRectPatchSize(
  877.         CONST FLOAT *pfNumSegs, //segments for each edge (4)
  878.         DWORD *pdwTriangles,    //output number of triangles
  879.         DWORD *pdwVertices);    //output number of vertices
  880.  
  881. //computes the size of a single triangle patch      
  882. HRESULT WINAPI
  883.     D3DXTriPatchSize(
  884.         CONST FLOAT *pfNumSegs, //segments for each edge (3)    
  885.         DWORD *pdwTriangles,    //output number of triangles
  886.         DWORD *pdwVertices);    //output number of vertices
  887.  
  888.  
  889. //tessellates a patch into a created mesh
  890. //similar to D3D RT patch
  891. HRESULT WINAPI
  892.     D3DXTessellateRectPatch(
  893.         LPDIRECT3DVERTEXBUFFER9 pVB,
  894.         CONST FLOAT *pNumSegs,
  895.         CONST D3DVERTEXELEMENT9 *pdwInDecl,
  896.         CONST D3DRECTPATCH_INFO *pRectPatchInfo,
  897.         LPD3DXMESH pMesh);
  898.  
  899.  
  900. HRESULT WINAPI
  901.     D3DXTessellateTriPatch(
  902.       LPDIRECT3DVERTEXBUFFER9 pVB,
  903.       CONST FLOAT *pNumSegs,
  904.       CONST D3DVERTEXELEMENT9 *pInDecl,
  905.       CONST D3DTRIPATCH_INFO *pTriPatchInfo,
  906.       LPD3DXMESH pMesh);
  907.  
  908.  
  909.  
  910. //creates an NPatch PatchMesh from a D3DXMESH 
  911. HRESULT WINAPI
  912.     D3DXCreateNPatchMesh(
  913.         LPD3DXMESH pMeshSysMem,
  914.         LPD3DXPATCHMESH *pPatchMesh);
  915.  
  916.       
  917. //creates a patch mesh
  918. HRESULT WINAPI
  919.     D3DXCreatePatchMesh(
  920.         LPD3DXPATCHINFO pInfo, //patch type
  921.         DWORD dwNumPatches,    //number of patches
  922.         DWORD dwNumVertices,   //number of control vertices
  923.         DWORD dwOptions,       //options 
  924.         CONST D3DVERTEXELEMENT9 *pDecl, //format of control vertices
  925.         LPDIRECT3DDEVICE9 pDevice, 
  926.         LPD3DXPATCHMESH *pPatchMesh);
  927.  
  928.         
  929. //returns the number of degenerates in a patch mesh -
  930. //text output put in string.
  931. HRESULT WINAPI
  932.     D3DXValidPatchMesh(THIS_ LPD3DXPATCHMESH pMesh,
  933.                         DWORD *dwcDegenerateVertices,
  934.                         DWORD *dwcDegeneratePatches,
  935.                         LPD3DXBUFFER *ppErrorsAndWarnings);
  936.  
  937. UINT WINAPI
  938.     D3DXGetFVFVertexSize(DWORD FVF);
  939.  
  940. UINT WINAPI 
  941.     D3DXGetDeclVertexSize(CONST D3DVERTEXELEMENT9 *pDecl,DWORD Stream);
  942.  
  943. UINT WINAPI 
  944.     D3DXGetDeclLength(CONST D3DVERTEXELEMENT9 *pDecl);
  945.  
  946. HRESULT WINAPI
  947.     D3DXDeclaratorFromFVF(
  948.         DWORD FVF,
  949.         D3DVERTEXELEMENT9 pDeclarator[MAX_FVF_DECL_SIZE]);
  950.  
  951. HRESULT WINAPI
  952.     D3DXFVFFromDeclarator(
  953.         CONST D3DVERTEXELEMENT9 *pDeclarator,
  954.         DWORD *pFVF);
  955.  
  956. HRESULT WINAPI 
  957.     D3DXWeldVertices(
  958.         CONST LPD3DXMESH pMesh,         
  959.         DWORD Flags,
  960.         CONST D3DXWELDEPSILONS *pEpsilons,                 
  961.         CONST DWORD *pAdjacencyIn, 
  962.         DWORD *pAdjacencyOut,
  963.         DWORD *pFaceRemap, 
  964.         LPD3DXBUFFER *ppVertexRemap);
  965.  
  966. typedef struct _D3DXINTERSECTINFO
  967. {
  968.     DWORD FaceIndex;                // index of face intersected
  969.     FLOAT U;                        // Barycentric Hit Coordinates    
  970.     FLOAT V;                        // Barycentric Hit Coordinates
  971.     FLOAT Dist;                     // Ray-Intersection Parameter Distance
  972. } D3DXINTERSECTINFO, *LPD3DXINTERSECTINFO;
  973.  
  974.  
  975. HRESULT WINAPI
  976.     D3DXIntersect(
  977.         LPD3DXBASEMESH pMesh,
  978.         CONST D3DXVECTOR3 *pRayPos,
  979.         CONST D3DXVECTOR3 *pRayDir, 
  980.         BOOL    *pHit,              // True if any faces were intersected
  981.         DWORD   *pFaceIndex,        // index of closest face intersected
  982.         FLOAT   *pU,                // Barycentric Hit Coordinates    
  983.         FLOAT   *pV,                // Barycentric Hit Coordinates
  984.         FLOAT   *pDist,             // Ray-Intersection Parameter Distance
  985.         LPD3DXBUFFER *ppAllHits,    // Array of D3DXINTERSECTINFOs for all hits (not just closest) 
  986.         DWORD   *pCountOfHits);     // Number of entries in AllHits array
  987.  
  988. HRESULT WINAPI
  989.     D3DXIntersectSubset(
  990.         LPD3DXBASEMESH pMesh,
  991.         DWORD AttribId,
  992.         CONST D3DXVECTOR3 *pRayPos,
  993.         CONST D3DXVECTOR3 *pRayDir, 
  994.         BOOL    *pHit,              // True if any faces were intersected
  995.         DWORD   *pFaceIndex,        // index of closest face intersected
  996.         FLOAT   *pU,                // Barycentric Hit Coordinates    
  997.         FLOAT   *pV,                // Barycentric Hit Coordinates
  998.         FLOAT   *pDist,             // Ray-Intersection Parameter Distance
  999.         LPD3DXBUFFER *ppAllHits,    // Array of D3DXINTERSECTINFOs for all hits (not just closest) 
  1000.         DWORD   *pCountOfHits);     // Number of entries in AllHits array
  1001.  
  1002.  
  1003. HRESULT WINAPI D3DXSplitMesh
  1004.     (
  1005.     CONST LPD3DXMESH pMeshIn,         
  1006.     CONST DWORD *pAdjacencyIn, 
  1007.     CONST DWORD MaxSize,
  1008.     CONST DWORD Options,
  1009.     DWORD *pMeshesOut,
  1010.     LPD3DXBUFFER *ppMeshArrayOut,
  1011.     LPD3DXBUFFER *ppAdjacencyArrayOut,
  1012.     LPD3DXBUFFER *ppFaceRemapArrayOut,
  1013.     LPD3DXBUFFER *ppVertRemapArrayOut
  1014.     );
  1015.  
  1016. BOOL WINAPI D3DXIntersectTri 
  1017. (
  1018.     CONST D3DXVECTOR3 *p0,           // Triangle vertex 0 position
  1019.     CONST D3DXVECTOR3 *p1,           // Triangle vertex 1 position
  1020.     CONST D3DXVECTOR3 *p2,           // Triangle vertex 2 position
  1021.     CONST D3DXVECTOR3 *pRayPos,      // Ray origin
  1022.     CONST D3DXVECTOR3 *pRayDir,      // Ray direction
  1023.     FLOAT *pU,                       // Barycentric Hit Coordinates
  1024.     FLOAT *pV,                       // Barycentric Hit Coordinates
  1025.     FLOAT *pDist);                   // Ray-Intersection Parameter Distance
  1026.  
  1027. BOOL WINAPI
  1028.     D3DXSphereBoundProbe(
  1029.         CONST D3DXVECTOR3 *pCenter,
  1030.         FLOAT Radius,
  1031.         CONST D3DXVECTOR3 *pRayPosition,
  1032.         CONST D3DXVECTOR3 *pRayDirection);
  1033.  
  1034. BOOL WINAPI 
  1035.     D3DXBoxBoundProbe(
  1036.         CONST D3DXVECTOR3 *pMin, 
  1037.         CONST D3DXVECTOR3 *pMax,
  1038.         CONST D3DXVECTOR3 *pRayPosition,
  1039.         CONST D3DXVECTOR3 *pRayDirection);
  1040.  
  1041.  
  1042.  
  1043. //D3DXComputeTangent
  1044. //
  1045. //Computes the Tangent vectors for the TexStage texture coordinates
  1046. //and places the results in the TANGENT[TangentIndex] specified in the meshes' DECL
  1047. //puts the binorm in BINORM[BinormIndex] also specified in the decl.
  1048. //
  1049. //If neither the binorm or the tangnet are in the meshes declaration,
  1050. //the function will fail. 
  1051. //
  1052. //If a tangent or Binorm field is in the Decl, but the user does not
  1053. //wish D3DXComputeTangent to replace them, then D3DX_DEFAULT specified
  1054. //in the TangentIndex or BinormIndex will cause it to ignore the specified 
  1055. //semantic.
  1056. //
  1057. //Wrap should be specified if the texture coordinates wrap.
  1058.  
  1059. HRESULT WINAPI D3DXComputeTangent(LPD3DXMESH Mesh,
  1060.                                  DWORD TexStage,
  1061.                                  DWORD TangentIndex,
  1062.                                  DWORD BinormIndex,
  1063.                                  DWORD Wrap,
  1064.                                  DWORD *Adjacency);
  1065.  
  1066. HRESULT WINAPI
  1067. D3DXConvertMeshSubsetToSingleStrip
  1068. (
  1069.     LPD3DXBASEMESH MeshIn,
  1070.     DWORD AttribId,
  1071.     DWORD IBOptions,
  1072.     LPDIRECT3DINDEXBUFFER9 *ppIndexBuffer,
  1073.     DWORD *pNumIndices
  1074. );
  1075.  
  1076. HRESULT WINAPI
  1077. D3DXConvertMeshSubsetToStrips
  1078. (
  1079.     LPD3DXBASEMESH MeshIn,
  1080.     DWORD AttribId,
  1081.     DWORD IBOptions,
  1082.     LPDIRECT3DINDEXBUFFER9 *ppIndexBuffer,
  1083.     DWORD *pNumIndices,
  1084.     LPD3DXBUFFER *ppStripLengths,
  1085.     DWORD *pNumStrips
  1086. );
  1087.  
  1088.  
  1089. #ifdef __cplusplus
  1090. }
  1091. #endif //__cplusplus
  1092.  
  1093. //////////////////////////////////////////////////////////////////////////////
  1094. //
  1095. //  Definitions of .X file templates used by mesh load/save functions 
  1096. //    that are not RM standard
  1097. //
  1098. //////////////////////////////////////////////////////////////////////////////
  1099.  
  1100. // {3CF169CE-FF7C-44ab-93C0-F78F62D172E2}
  1101. DEFINE_GUID(DXFILEOBJ_XSkinMeshHeader,
  1102. 0x3cf169ce, 0xff7c, 0x44ab, 0x93, 0xc0, 0xf7, 0x8f, 0x62, 0xd1, 0x72, 0xe2);
  1103.  
  1104. // {B8D65549-D7C9-4995-89CF-53A9A8B031E3}
  1105. DEFINE_GUID(DXFILEOBJ_VertexDuplicationIndices, 
  1106. 0xb8d65549, 0xd7c9, 0x4995, 0x89, 0xcf, 0x53, 0xa9, 0xa8, 0xb0, 0x31, 0xe3);
  1107.  
  1108. // {A64C844A-E282-4756-8B80-250CDE04398C}
  1109. DEFINE_GUID(DXFILEOBJ_FaceAdjacency, 
  1110. 0xa64c844a, 0xe282, 0x4756, 0x8b, 0x80, 0x25, 0xc, 0xde, 0x4, 0x39, 0x8c);
  1111.  
  1112. // {6F0D123B-BAD2-4167-A0D0-80224F25FABB}
  1113. DEFINE_GUID(DXFILEOBJ_SkinWeights, 
  1114. 0x6f0d123b, 0xbad2, 0x4167, 0xa0, 0xd0, 0x80, 0x22, 0x4f, 0x25, 0xfa, 0xbb);
  1115.  
  1116. // {A3EB5D44-FC22-429d-9AFB-3221CB9719A6}
  1117. DEFINE_GUID(DXFILEOBJ_Patch, 
  1118. 0xa3eb5d44, 0xfc22, 0x429d, 0x9a, 0xfb, 0x32, 0x21, 0xcb, 0x97, 0x19, 0xa6);
  1119.  
  1120. // {D02C95CC-EDBA-4305-9B5D-1820D7704BBF}
  1121. DEFINE_GUID(DXFILEOBJ_PatchMesh, 
  1122. 0xd02c95cc, 0xedba, 0x4305, 0x9b, 0x5d, 0x18, 0x20, 0xd7, 0x70, 0x4b, 0xbf);
  1123.  
  1124. // {B9EC94E1-B9A6-4251-BA18-94893F02C0EA}
  1125. DEFINE_GUID(DXFILEOBJ_PatchMesh9, 
  1126. 0xb9ec94e1, 0xb9a6, 0x4251, 0xba, 0x18, 0x94, 0x89, 0x3f, 0x2, 0xc0, 0xea);
  1127.  
  1128. // {B6C3E656-EC8B-4b92-9B62-681659522947}
  1129. DEFINE_GUID(DXFILEOBJ_PMInfo, 
  1130. 0xb6c3e656, 0xec8b, 0x4b92, 0x9b, 0x62, 0x68, 0x16, 0x59, 0x52, 0x29, 0x47);
  1131.  
  1132. // {917E0427-C61E-4a14-9C64-AFE65F9E9844}
  1133. DEFINE_GUID(DXFILEOBJ_PMAttributeRange, 
  1134. 0x917e0427, 0xc61e, 0x4a14, 0x9c, 0x64, 0xaf, 0xe6, 0x5f, 0x9e, 0x98, 0x44);
  1135.  
  1136. // {574CCC14-F0B3-4333-822D-93E8A8A08E4C}
  1137. DEFINE_GUID(DXFILEOBJ_PMVSplitRecord,
  1138. 0x574ccc14, 0xf0b3, 0x4333, 0x82, 0x2d, 0x93, 0xe8, 0xa8, 0xa0, 0x8e, 0x4c);
  1139.  
  1140. // {B6E70A0E-8EF9-4e83-94AD-ECC8B0C04897}
  1141. DEFINE_GUID(DXFILEOBJ_FVFData, 
  1142. 0xb6e70a0e, 0x8ef9, 0x4e83, 0x94, 0xad, 0xec, 0xc8, 0xb0, 0xc0, 0x48, 0x97);
  1143.  
  1144. // {F752461C-1E23-48f6-B9F8-8350850F336F}
  1145. DEFINE_GUID(DXFILEOBJ_VertexElement, 
  1146. 0xf752461c, 0x1e23, 0x48f6, 0xb9, 0xf8, 0x83, 0x50, 0x85, 0xf, 0x33, 0x6f);
  1147.  
  1148. // {BF22E553-292C-4781-9FEA-62BD554BDD93}
  1149. DEFINE_GUID(DXFILEOBJ_DeclData, 
  1150. 0xbf22e553, 0x292c, 0x4781, 0x9f, 0xea, 0x62, 0xbd, 0x55, 0x4b, 0xdd, 0x93);
  1151.  
  1152. // {F1CFE2B3-0DE3-4e28-AFA1-155A750A282D}
  1153. DEFINE_GUID(DXFILEOBJ_EffectFloats, 
  1154. 0xf1cfe2b3, 0xde3, 0x4e28, 0xaf, 0xa1, 0x15, 0x5a, 0x75, 0xa, 0x28, 0x2d);
  1155.  
  1156. // {D55B097E-BDB6-4c52-B03D-6051C89D0E42}
  1157. DEFINE_GUID(DXFILEOBJ_EffectString, 
  1158. 0xd55b097e, 0xbdb6, 0x4c52, 0xb0, 0x3d, 0x60, 0x51, 0xc8, 0x9d, 0xe, 0x42);
  1159.  
  1160. // {622C0ED0-956E-4da9-908A-2AF94F3CE716}
  1161. DEFINE_GUID(DXFILEOBJ_EffectDWord, 
  1162. 0x622c0ed0, 0x956e, 0x4da9, 0x90, 0x8a, 0x2a, 0xf9, 0x4f, 0x3c, 0xe7, 0x16);
  1163.  
  1164. // {3014B9A0-62F5-478c-9B86-E4AC9F4E418B}
  1165. DEFINE_GUID(DXFILEOBJ_EffectParamFloats, 
  1166. 0x3014b9a0, 0x62f5, 0x478c, 0x9b, 0x86, 0xe4, 0xac, 0x9f, 0x4e, 0x41, 0x8b);
  1167.  
  1168. // {1DBC4C88-94C1-46ee-9076-2C28818C9481}
  1169. DEFINE_GUID(DXFILEOBJ_EffectParamString, 
  1170. 0x1dbc4c88, 0x94c1, 0x46ee, 0x90, 0x76, 0x2c, 0x28, 0x81, 0x8c, 0x94, 0x81);
  1171.  
  1172. // {E13963BC-AE51-4c5d-B00F-CFA3A9D97CE5}
  1173. DEFINE_GUID(DXFILEOBJ_EffectParamDWord,
  1174. 0xe13963bc, 0xae51, 0x4c5d, 0xb0, 0xf, 0xcf, 0xa3, 0xa9, 0xd9, 0x7c, 0xe5);
  1175.  
  1176. // {E331F7E4-0559-4cc2-8E99-1CEC1657928F}
  1177. DEFINE_GUID(DXFILEOBJ_EffectInstance, 
  1178. 0xe331f7e4, 0x559, 0x4cc2, 0x8e, 0x99, 0x1c, 0xec, 0x16, 0x57, 0x92, 0x8f);
  1179.  
  1180. // {9E415A43-7BA6-4a73-8743-B73D47E88476}
  1181. DEFINE_GUID(DXFILEOBJ_AnimTicksPerSecond, 
  1182. 0x9e415a43, 0x7ba6, 0x4a73, 0x87, 0x43, 0xb7, 0x3d, 0x47, 0xe8, 0x84, 0x76);
  1183.  
  1184. #define XSKINEXP_TEMPLATES \
  1185.         "xof 0303txt 0032\
  1186.         template XSkinMeshHeader \
  1187.         { \
  1188.             <3CF169CE-FF7C-44ab-93C0-F78F62D172E2> \
  1189.             WORD nMaxSkinWeightsPerVertex; \
  1190.             WORD nMaxSkinWeightsPerFace; \
  1191.             WORD nBones; \
  1192.         } \
  1193.         template VertexDuplicationIndices \
  1194.         { \
  1195.             <B8D65549-D7C9-4995-89CF-53A9A8B031E3> \
  1196.             DWORD nIndices; \
  1197.             DWORD nOriginalVertices; \
  1198.             array DWORD indices[nIndices]; \
  1199.         } \
  1200.         template FaceAdjacency \
  1201.         { \
  1202.             <A64C844A-E282-4756-8B80-250CDE04398C> \
  1203.             DWORD nIndices; \
  1204.             array DWORD indices[nIndices]; \
  1205.         } \
  1206.         template SkinWeights \
  1207.         { \
  1208.             <6F0D123B-BAD2-4167-A0D0-80224F25FABB> \
  1209.             STRING transformNodeName; \
  1210.             DWORD nWeights; \
  1211.             array DWORD vertexIndices[nWeights]; \
  1212.             array float weights[nWeights]; \
  1213.             Matrix4x4 matrixOffset; \
  1214.         } \
  1215.         template Patch \
  1216.         { \
  1217.             <A3EB5D44-FC22-429D-9AFB-3221CB9719A6> \
  1218.             DWORD nControlIndices; \
  1219.             array DWORD controlIndices[nControlIndices]; \
  1220.         } \
  1221.         template PatchMesh \
  1222.         { \
  1223.             <D02C95CC-EDBA-4305-9B5D-1820D7704BBF> \
  1224.             DWORD nVertices; \
  1225.             array Vector vertices[nVertices]; \
  1226.             DWORD nPatches; \
  1227.             array Patch patches[nPatches]; \
  1228.             [ ... ] \
  1229.         } \
  1230.         template PatchMesh9 \
  1231.         { \
  1232.             <B9EC94E1-B9A6-4251-BA18-94893F02C0EA> \
  1233.             DWORD Type; \
  1234.             DWORD Degree; \
  1235.             DWORD Basis; \
  1236.             DWORD nVertices; \
  1237.             array Vector vertices[nVertices]; \
  1238.             DWORD nPatches; \
  1239.             array Patch patches[nPatches]; \
  1240.             [ ... ] \
  1241.         } " \
  1242.         "template EffectFloats \
  1243.         { \
  1244.             <F1CFE2B3-0DE3-4e28-AFA1-155A750A282D> \
  1245.             DWORD nFloats; \
  1246.             array float Floats[nFloats]; \
  1247.         } \
  1248.         template EffectString \
  1249.         { \
  1250.             <D55B097E-BDB6-4c52-B03D-6051C89D0E42> \
  1251.             STRING Value; \
  1252.         } \
  1253.         template EffectDWord \
  1254.         { \
  1255.             <622C0ED0-956E-4da9-908A-2AF94F3CE716> \
  1256.             DWORD Value; \
  1257.         } " \
  1258.         "template EffectParamFloats \
  1259.         { \
  1260.             <3014B9A0-62F5-478c-9B86-E4AC9F4E418B> \
  1261.             STRING ParamName; \
  1262.             DWORD nFloats; \
  1263.             array float Floats[nFloats]; \
  1264.         } " \
  1265.         "template EffectParamString \
  1266.         { \
  1267.             <1DBC4C88-94C1-46ee-9076-2C28818C9481> \
  1268.             STRING ParamName; \
  1269.             STRING Value; \
  1270.         } \
  1271.         template EffectParamDWord \
  1272.         { \
  1273.             <E13963BC-AE51-4c5d-B00F-CFA3A9D97CE5> \
  1274.             STRING ParamName; \
  1275.             DWORD Value; \
  1276.         } \
  1277.         template EffectInstance \
  1278.         { \
  1279.             <E331F7E4-0559-4cc2-8E99-1CEC1657928F> \
  1280.             STRING EffectFilename; \
  1281.             [ ... ] \
  1282.         } " \
  1283.         "template AnimTicksPerSecond \
  1284.         { \
  1285.             <9E415A43-7BA6-4a73-8743-B73D47E88476> \
  1286.             DWORD AnimTicksPerSecond; \
  1287.         } "
  1288.  
  1289. #define XEXTENSIONS_TEMPLATES \
  1290.         "xof 0303txt 0032\
  1291.         template FVFData \
  1292.         { \
  1293.             <B6E70A0E-8EF9-4e83-94AD-ECC8B0C04897> \
  1294.             DWORD dwFVF; \
  1295.             DWORD nDWords; \
  1296.             array DWORD data[nDWords]; \
  1297.         } \
  1298.         template VertexElement \
  1299.         { \
  1300.             <F752461C-1E23-48f6-B9F8-8350850F336F> \
  1301.             DWORD Type; \
  1302.             DWORD Method; \
  1303.             DWORD Usage; \
  1304.             DWORD UsageIndex; \
  1305.         } \
  1306.         template DeclData \
  1307.         { \
  1308.             <BF22E553-292C-4781-9FEA-62BD554BDD93> \
  1309.             DWORD nElements; \
  1310.             array VertexElement Elements[nElements]; \
  1311.             DWORD nDWords; \
  1312.             array DWORD data[nDWords]; \
  1313.         } \
  1314.         template PMAttributeRange \
  1315.         { \
  1316.             <917E0427-C61E-4a14-9C64-AFE65F9E9844> \
  1317.             DWORD iFaceOffset; \
  1318.             DWORD nFacesMin; \
  1319.             DWORD nFacesMax; \
  1320.             DWORD iVertexOffset; \
  1321.             DWORD nVerticesMin; \
  1322.             DWORD nVerticesMax; \
  1323.         } \
  1324.         template PMVSplitRecord \
  1325.         { \
  1326.             <574CCC14-F0B3-4333-822D-93E8A8A08E4C> \
  1327.             DWORD iFaceCLW; \
  1328.             DWORD iVlrOffset; \
  1329.             DWORD iCode; \
  1330.         } \
  1331.         template PMInfo \
  1332.         { \
  1333.             <B6C3E656-EC8B-4b92-9B62-681659522947> \
  1334.             DWORD nAttributes; \
  1335.             array PMAttributeRange attributeRanges[nAttributes]; \
  1336.             DWORD nMaxValence; \
  1337.             DWORD nMinLogicalVertices; \
  1338.             DWORD nMaxLogicalVertices; \
  1339.             DWORD nVSplits; \
  1340.             array PMVSplitRecord splitRecords[nVSplits]; \
  1341.             DWORD nAttributeMispredicts; \
  1342.             array DWORD attributeMispredicts[nAttributeMispredicts]; \
  1343.         } "
  1344.         
  1345. #endif //__D3DX9MESH_H__
  1346.  
  1347.  
  1348.